home *** CD-ROM | disk | FTP | other *** search
/ EuroCD 3 / EuroCD 3.iso / Graphics_Utils / CyberGraphX / CyberAnim / src / unpack.s < prev   
Encoding:
Text File  |  1998-06-24  |  34.1 KB  |  1,436 lines
  1. ;;;;        debug    on,lattice4,code,data
  2.         multipass
  3.         mc68000
  4.  
  5.         xdef    _unpackbytedelta
  6.         xdef    _unpackbytedeltaxor
  7.         xdef    _unpackbytedeltanodirty
  8.         xdef    _unpackbytedeltanodirtyxor
  9.         xdef    _unpackanim7long
  10.         xdef    _unpackanim7longnodirty
  11.         xdef    _unpackanim7word
  12.         xdef    _unpackanim7wordnodirty
  13.         xdef    _unpackanim8long
  14.         xdef    _unpackanim8longnodirty
  15.         xdef    _unpackanim8word
  16.         xdef    _unpackanim8wordnodirty
  17.  
  18. ;***********************************************************************
  19.  
  20. ;void __asm unpackbytedelta (register __a0 BYTE *bdata,
  21. ;                            register __a1 PLANEPTR plane,
  22. ;                            register __d0 WORD bytesperrow,
  23. ;                            register __a2 WORD *dirty);
  24.  
  25. ; d1 = x
  26. ; d2 = tmp
  27. ; d3 = count
  28. ; d4 = w
  29. ; d5 = first
  30. ; d6 = last
  31. ; d7 = ub, temporary
  32.  
  33. ; a3 = bp
  34. ; a4 = y
  35.  
  36. _unpackbytedelta
  37.         movem.l    d2-d7/a2-a4,-(sp)
  38.         ext.l    d0        ; bytesperrow
  39.         moveq    #0,d1        ; x = 0
  40. .xloop        moveq    #-1,d5        ; first = -1
  41.         moveq    #-1,d6        ; last = -1
  42.         movea.l    a1,a3        ; bp = plane
  43.         addq.l    #1,a1        ; plane++
  44.         suba.l    a4,a4        ; y = 0
  45.         moveq    #0,d3
  46.         move.b    (a0)+,d3    ; count = *bdata++
  47.         bra    .endloop2
  48. .loop2        moveq    #0,d4
  49.         move.b    (a0)+,d4    ; w = *bdata++
  50.         ble    1$        ; branch if w <= 0
  51.         adda.l    d4,a4        ; y += w
  52.         mulu.w    d0,d4
  53.         adda.l    d4,a3        ; bp += w * bytesperrow
  54. .endloop2    dbra    d3,.loop2
  55.         bra    .endxloop
  56.  
  57. 1$        beq    3$        ; branch if w == 0
  58.         tst.w    d5
  59.         bge    2$        ; branch if first >= 0
  60.         move.w    a4,d5        ; first = y
  61. 2$        and.w    #$7f,d4        ; w &= 0x7f
  62.         adda.l    d4,a4        ; y += w
  63.         move.w    a4,d6        ; last = y
  64.         move.w    d4,d7
  65.         lsr.w    #3,d4
  66.         and.w    #7,d7
  67.         add.w    d7,d7
  68.         add.w    d7,d7
  69.         neg.w    d7
  70.         jmp    (.endwloop,pc,d7.w)
  71. .wloop        move.b    (a0)+,(a3)    ; *bp = *data++
  72.         adda.l    d0,a3        ; bp += bytesperrow
  73.         move.b    (a0)+,(a3)    ; *bp = *data++
  74.         adda.l    d0,a3        ; bp += bytesperrow
  75.         move.b    (a0)+,(a3)    ; *bp = *data++
  76.         adda.l    d0,a3        ; bp += bytesperrow
  77.         move.b    (a0)+,(a3)    ; *bp = *data++
  78.         adda.l    d0,a3        ; bp += bytesperrow
  79.         move.b    (a0)+,(a3)    ; *bp = *data++
  80.         adda.l    d0,a3        ; bp += bytesperrow
  81.         move.b    (a0)+,(a3)    ; *bp = *data++
  82.         adda.l    d0,a3        ; bp += bytesperrow
  83.         move.b    (a0)+,(a3)    ; *bp = *data++
  84.         adda.l    d0,a3        ; bp += bytesperrow
  85.         move.b    (a0)+,(a3)    ; *bp = *data++
  86.         adda.l    d0,a3        ; bp += bytesperrow
  87. .endwloop    dbra    d4,.wloop
  88.         dbra    d3,.loop2
  89.         bra    .endxloop
  90.  
  91. 3$        tst.w    d5
  92.         bge    4$        ; branch if first >= 0
  93.         move.w    a4,d5        ; first = y
  94. 4$        moveq    #0,d7
  95.         move.b    (a0)+,d7    ; ub = *bdata++
  96.         adda.l    d7,a4        ; y += ub
  97.         move.w    a4,d6        ; last = y
  98.         move.b    (a0)+,d4    ; w = *bdata++
  99.         move.w    d7,d2
  100.         lsr.w    #3,d7
  101.         and.w    #7,d2
  102.         add.w    d2,d2
  103.         add.w    d2,d2
  104.         neg.w    d2
  105.         jmp    (.endubloop,pc,d2.w)
  106. .ubloop        move.b    d4,(a3)        ; *bp = w
  107.         adda.l    d0,a3        ; bp += bytesperrow
  108.         move.b    d4,(a3)        ; *bp = w
  109.         adda.l    d0,a3        ; bp += bytesperrow
  110.         move.b    d4,(a3)        ; *bp = w
  111.         adda.l    d0,a3        ; bp += bytesperrow
  112.         move.b    d4,(a3)        ; *bp = w
  113.         adda.l    d0,a3        ; bp += bytesperrow
  114.         move.b    d4,(a3)        ; *bp = w
  115.         adda.l    d0,a3        ; bp += bytesperrow
  116.         move.b    d4,(a3)        ; *bp = w
  117.         adda.l    d0,a3        ; bp += bytesperrow
  118.         move.b    d4,(a3)        ; *bp = w
  119.         adda.l    d0,a3        ; bp += bytesperrow
  120.         move.b    d4,(a3)        ; *bp = w
  121.         adda.l    d0,a3        ; bp += bytesperrow
  122. .endubloop    dbra    d7,.ubloop
  123.  
  124.         dbra    d3,.loop2
  125.  
  126. .endxloop    tst.w    d5
  127.         blt    8$        ; branch if first < 0
  128.         move.w    (a2),d7
  129.         blt    5$        ; branch if dirty[0] < 0
  130.         cmp.w    d5,d7
  131.         ble    6$        ; branch if dirty[0] <= first
  132. 5$        move.w    d5,(a2)        ; dirty[0] = first
  133. 6$        move.w    (2,a2),d7
  134.         blt    7$        ; branch if dirty[1] < 0
  135.         cmp.w    d6,d7
  136.         bge    8$        ; branch if dirty[1] >= last
  137. 7$        move.w    d6,(2,a2)    ; dirty[1] = last
  138. 8$        move.w    d1,d7
  139.         and.w    #3,d7
  140.         cmp.w    #3,d7
  141.         bne    9$
  142.         addq.l    #4,a2        ; dirty += 2
  143. 9$        addq.w    #1,d1        ; x++
  144.         cmp.w    d0,d1
  145.         blt    .xloop        ; branch if x < bytesperrow
  146.         movem.l    (sp)+,d2-d7/a2-a4
  147.         rts
  148.  
  149. ;{
  150. ;  WORD x, y, count, w, first, last;
  151. ;  BYTE *bp;
  152. ;  UBYTE ub;
  153. ;
  154. ;  for (x = 0; x < bytesperrow; x++) {
  155. ;    first = -1;
  156. ;    last = -1;
  157. ;    bp = &plane[x];
  158. ;    y = 0;
  159. ;    for (count = *bdata++; count > 0; count--) {
  160. ;      if ((w = *bdata++) > 0) {
  161. ;        y += w;
  162. ;        bp += w * bytesperrow;
  163. ;      } else if (w < 0) {
  164. ;        if (first < 0)
  165. ;          first = y;
  166. ;        last = (y += (w &= 0x7f));
  167. ;        for ( ; w > 0; w--) {
  168. ;          *bp = *bdata++;
  169. ;          bp += bytesperrow;
  170. ;        }
  171. ;      } else /* w == 0 */ {
  172. ;        if (first < 0)
  173. ;          first = y;
  174. ;        last = (y += (ub = (UBYTE)*bdata++));
  175. ;        w = *bdata++;
  176. ;        for ( ; ub > 0; ub--) {
  177. ;          *bp = w;
  178. ;          bp += bytesperrow;
  179. ;        }
  180. ;      }
  181. ;    }
  182. ;    if (first >= 0 && (dirty[0] < 0 || first < dirty[0]))
  183. ;      dirty[0] = first;
  184. ;    if (last >= 0 && (dirty[1] < 0 || last > dirty[1]))
  185. ;      dirty[1] = last;
  186. ;    if ((x & 3) == 3)
  187. ;      dirty += 2;
  188. ;  }
  189. ;}
  190.  
  191. ;***********************************************************************
  192.  
  193. ;void __asm unpackbytedeltaxor (register __a0 BYTE *bdata,
  194. ;                               register __a1 PLANEPTR plane,
  195. ;                               register __d0 WORD bytesperrow,
  196. ;                               register __a2 WORD *dirty);
  197.  
  198. ; d1 = x
  199. ; d2 = tmp
  200. ; d3 = count
  201. ; d4 = w
  202. ; d5 = first
  203. ; d6 = last
  204. ; d7 = ub, temporary
  205.  
  206. ; a3 = bp
  207. ; a4 = y
  208.  
  209. _unpackbytedeltaxor
  210.         movem.l    d2-d7/a2-a4,-(sp)
  211.         ext.l    d0        ; bytesperrow
  212.         moveq    #0,d1        ; x = 0
  213. .xloop        moveq    #-1,d5        ; first = -1
  214.         moveq    #-1,d6        ; last = -1
  215.         movea.l    a1,a3        ; bp = plane
  216.         addq.l    #1,a1        ; plane++
  217.         suba.l    a4,a4        ; y = 0
  218.         moveq    #0,d3
  219.         move.b    (a0)+,d3    ; count = *bdata++
  220.         bra    .endloop2
  221. .loop2        moveq    #0,d4
  222.         move.b    (a0)+,d4    ; w = *bdata++
  223.         ble    1$        ; branch if w <= 0
  224.         adda.l    d4,a4        ; y += w
  225.         mulu.w    d0,d4
  226.         adda.l    d4,a3        ; bp += w * bytesperrow
  227. .endloop2    dbra    d3,.loop2
  228.         bra    .endxloop
  229.  
  230. 1$        beq    3$        ; branch if w == 0
  231.         tst.w    d5
  232.         bge    2$        ; branch if first >= 0
  233.         move.w    a4,d5        ; first = y
  234. 2$        and.w    #$7f,d4        ; w &= 0x7f
  235.         adda.l    d4,a4        ; y += w
  236.         move.w    a4,d6        ; last = y
  237.         move.w    d4,d7
  238.         lsr.w    #3,d4
  239.         and.w    #7,d7
  240.  
  241.         add.w    d7,d7
  242.         move.w    d7,d2
  243.         add.w    d7,d7
  244.         add.w    d2,d7
  245.  
  246.         neg.w    d7
  247.         jmp    (.endwloop,pc,d7.w)
  248. .wloop
  249.         REPT    8
  250.         move.b    (a0)+,d7    ; tmp = *data++
  251.         eor.b    d7,(a3)        ; *bp ^= tmp
  252.         adda.l    d0,a3        ; bp += bytesperrow
  253.         ENDR
  254.  
  255. .endwloop    dbra    d4,.wloop
  256.         dbra    d3,.loop2
  257.         bra    .endxloop
  258.  
  259. 3$        tst.w    d5
  260.         bge    4$        ; branch if first >= 0
  261.         move.w    a4,d5        ; first = y
  262. 4$        moveq    #0,d7
  263.         move.b    (a0)+,d7    ; ub = *bdata++
  264.         adda.l    d7,a4        ; y += ub
  265.         move.w    a4,d6        ; last = y
  266.         move.b    (a0)+,d4    ; w = *bdata++
  267.         move.w    d7,d2
  268.         lsr.w    #3,d7
  269.         and.w    #7,d2
  270.  
  271.         add.w    d2,d2
  272.         add.w    d2,d2
  273.  
  274.         neg.w    d2
  275.         jmp    (.endubloop,pc,d2.w)
  276. .ubloop
  277.         REPT 8
  278.         eor.b    d4,(a3)        ; *bp ^= w
  279.         adda.l    d0,a3        ; bp += bytesperrow
  280.         ENDR
  281.  
  282. .endubloop    dbra    d7,.ubloop
  283.  
  284.         dbra    d3,.loop2
  285.  
  286. .endxloop    tst.w    d5
  287.         blt    8$        ; branch if first < 0
  288.         move.w    (a2),d7
  289.         blt    5$        ; branch if dirty[0] < 0
  290.         cmp.w    d5,d7
  291.         ble    6$        ; branch if dirty[0] <= first
  292. 5$        move.w    d5,(a2)        ; dirty[0] = first
  293. 6$        move.w    (2,a2),d7
  294.         blt    7$        ; branch if dirty[1] < 0
  295.         cmp.w    d6,d7
  296.         bge    8$        ; branch if dirty[1] >= last
  297. 7$        move.w    d6,(2,a2)    ; dirty[1] = last
  298. 8$        move.w    d1,d7
  299.         and.w    #3,d7
  300.         cmp.w    #3,d7
  301.         bne    9$
  302.         addq.l    #4,a2        ; dirty += 2
  303. 9$        addq.w    #1,d1        ; x++
  304.         cmp.w    d0,d1
  305.         blt    .xloop        ; branch if x < bytesperrow
  306.         movem.l    (sp)+,d2-d7/a2-a4
  307.         rts
  308.  
  309. ;***********************************************************************
  310.  
  311. ;void __asm unpackbytedeltanodirty (register __a0 BYTE *bdata,
  312. ;                                   register __a1 PLANEPTR plane,
  313. ;                                   register __d0 WORD bytesperrow);
  314.  
  315. ; d1 = bytesperrrow - x
  316. ; d3 = count
  317. ; d4 = w
  318. ; d7 = ub, temporary
  319.  
  320. ; a3 = bp
  321.  
  322. _unpackbytedeltanodirty
  323.         movem.l    d2-d7/a2-a3,-(sp)
  324.         ext.l    d0        ; bytesperrow
  325.         move.l    d0,d1        ; x
  326.         bra    .endxloop
  327. .xloop        movea.l    a1,a3        ; bp = plane
  328.         addq.l    #1,a1        ; plane++
  329.         moveq    #0,d3
  330.         move.b    (a0)+,d3    ; count = *bdata++
  331.         bra    .endloop2
  332.  
  333. .loop2        moveq    #0,d4
  334.         move.b    (a0)+,d4    ; w = *bdata++
  335.         ble    1$        ; branch if w <= 0
  336.         mulu.w    d0,d4
  337.         adda.l    d4,a3        ; bp += w * bytesperrow
  338.  
  339. .endloop2    dbra    d3,.loop2
  340.         bra    .endxloop
  341.  
  342. 1$        beq    3$        ; branch if w == 0
  343.         and.w    #$7f,d4        ; w &= 0x7f
  344.         move.w    d4,d6
  345.         lsr.w    #3,d4
  346.         and.w    #7,d6
  347.         add.w    d6,d6
  348.         add.w    d6,d6
  349.         neg.w    d6
  350.         jmp    (.endwloop,pc,d6.w)
  351. .wloop        move.b    (a0)+,(a3)    ; *lp = *data++
  352.         adda.l    d0,a3        ; lp += bytesperrow
  353.         move.b    (a0)+,(a3)    ; *lp = *data++
  354.         adda.l    d0,a3        ; lp += bytesperrow
  355.         move.b    (a0)+,(a3)    ; *lp = *data++
  356.         adda.l    d0,a3        ; lp += bytesperrow
  357.         move.b    (a0)+,(a3)    ; *lp = *data++
  358.         adda.l    d0,a3        ; lp += bytesperrow
  359.         move.b    (a0)+,(a3)    ; *lp = *data++
  360.         adda.l    d0,a3        ; lp += bytesperrow
  361.         move.b    (a0)+,(a3)    ; *lp = *data++
  362.         adda.l    d0,a3        ; lp += bytesperrow
  363.         move.b    (a0)+,(a3)    ; *lp = *data++
  364.         adda.l    d0,a3        ; lp += bytesperrow
  365.         move.b    (a0)+,(a3)    ; *lp = *data++
  366.         adda.l    d0,a3        ; lp += bytesperrow
  367. .endwloop    dbra    d4,.wloop
  368.  
  369.         dbra    d3,.loop2
  370.         bra    .endxloop
  371.  
  372. 3$        moveq    #0,d7
  373.         move.b    (a0)+,d7    ; ub = *bdata++
  374.         move.b    (a0)+,d4    ; w = *bdata++
  375.         move.w    d7,d6
  376.         lsr.w    #3,d7
  377.         and.w    #7,d6
  378.         add.w    d6,d6
  379.         add.w    d6,d6
  380.         neg.w    d6
  381.         jmp    (.endubloop,pc,d6.w)
  382. .ubloop        move.b    d4,(a3)        ; *lp = w
  383.         adda.l    d0,a3        ; lp += bytesperrow
  384.         move.b    d4,(a3)        ; *lp = w
  385.         adda.l    d0,a3        ; lp += bytesperrow
  386.         move.b    d4,(a3)        ; *lp = w
  387.         adda.l    d0,a3        ; lp += bytesperrow
  388.         move.b    d4,(a3)        ; *lp = w
  389.         adda.l    d0,a3        ; lp += bytesperrow
  390.         move.b    d4,(a3)        ; *lp = w
  391.         adda.l    d0,a3        ; lp += bytesperrow
  392.         move.b    d4,(a3)        ; *lp = w
  393.         adda.l    d0,a3        ; lp += bytesperrow
  394.         move.b    d4,(a3)        ; *lp = w
  395.         adda.l    d0,a3        ; lp += bytesperrow
  396.         move.b    d4,(a3)        ; *lp = w
  397.         adda.l    d0,a3        ; lp += bytesperrow
  398. .endubloop    dbra    d7,.ubloop
  399.  
  400.         dbra    d3,.loop2
  401.  
  402. .endxloop    dbra    d1,.xloop
  403.         movem.l    (sp)+,d2-d7/a2-a3
  404.         rts
  405.  
  406. ;***********************************************************************
  407.  
  408. ;void __asm unpackbytedeltanodirtyxor (register __a0 BYTE *bdata,
  409. ;                                      register __a1 PLANEPTR plane,
  410. ;                                      register __a4 PLANEPTR otherplane,
  411. ;                                      register __d0 WORD bytesperrow,
  412. ;                                      register __d2 int height);
  413.  
  414. ; d1 = bytesperrrow - x
  415. ; d2 = height
  416. ; d3 = count
  417. ; d4 = w
  418. ; d5 = y
  419. ; d7 = ub, temporary
  420.  
  421. ; a3 = bp
  422. ; a5 = otherbp
  423.  
  424. _unpackbytedeltanodirtyxor
  425.         movem.l    d2-d7/a2-a5,-(sp)
  426.         ext.l    d0        ; bytesperrow
  427.         move.l    d0,d1        ; x
  428.         bra    .endxloop
  429. .xloop        movea.l    a1,a3        ; bp = plane
  430.         addq.l    #1,a1        ; plane++
  431.         movea.l    a4,a5        ; otherbp = otherplane
  432.         addq.l    #1,a4        ; otherplane++
  433.         move.w    d2,d5        ; y = height
  434.         moveq    #0,d3
  435.         move.b    (a0)+,d3    ; count = *bdata++
  436.         bra    .endloop2
  437.  
  438. .loop2        moveq    #0,d4
  439.         move.b    (a0)+,d4    ; w = *bdata++
  440.         ble    1$        ; branch if w <= 0
  441.  
  442.         sub.w    d4,d5        ; y -= w
  443.  
  444.         move.w    d4,d6
  445.         lsr.w    #3,d4
  446.         and.w    #7,d6
  447.  
  448.         mulu.w    #6,d6
  449.         neg.w    d6
  450.         jmp    (.endcopyloop,pc,d6.w)
  451.  
  452. .copyloop    REPT    8
  453.         move.b    (a5),(a3)    ; *bp = *otherbp
  454.         adda.l    d0,a5        ; otherbp += bytesperrow
  455.         adda.l    d0,a3        ; bp += bytesperrow
  456.         ENDR
  457. .endcopyloop
  458.         dbra    d4,.copyloop
  459.  
  460. .endloop2    dbra    d3,.loop2
  461.         bra    .endx
  462.  
  463. 1$        beq    3$        ; branch if w == 0
  464.         and.w    #$7f,d4        ; w &= 0x7f
  465.  
  466.         sub.w    d4,d5        ; y -= w
  467.  
  468.         move.w    d4,d6
  469.         lsr.w    #3,d4
  470.         and.w    #7,d6
  471.  
  472.         mulu.w    #12,d6
  473.  
  474.         neg.w    d6
  475.         jmp    (.endwloop,pc,d6.w)
  476. .wloop
  477.         REPT    8
  478.         move.b    (a5),d6        ; tmp = *otherbp
  479.         adda.l    d0,a5        ; otherbp += bytesperrow
  480.         move.b    (a0)+,d7    ; tmp2 = *data++
  481.         eor.b    d7,d6        ; tmp ^= tmp2
  482.         move.b    d6,(a3)        ; *bp = tmp
  483.         adda.l    d0,a3        ; bp += bytesperrow
  484.         ENDR
  485.  
  486. .endwloop    dbra    d4,.wloop
  487.  
  488.         dbra    d3,.loop2
  489.         bra    .endx
  490.  
  491. 3$        moveq    #0,d7
  492.         move.b    (a0)+,d7    ; ub = *bdata++
  493.         move.b    (a0)+,d4    ; w = *bdata++
  494.  
  495.         sub.w    d7,d5        ; y -= ub
  496.  
  497.         move.w    d7,d6
  498.         lsr.w    #3,d7
  499.         and.w    #7,d6
  500.  
  501.         mulu.w    #10,d6
  502.  
  503.         neg.w    d6
  504.         jmp    (.endubloop,pc,d6.w)
  505. .ubloop
  506.         REPT    8
  507.         move.b    (a5),d6        ; tmp = *otherbp
  508.         adda.l    d0,a5        ; otherbp += bytesperrow
  509.         eor.b    d4,d6        ; tmp ^= w
  510.         move.b    d6,(a3)        ; *bp = tmp
  511.         adda.l    d0,a3        ; bp += bytesperrow
  512.         ENDR
  513.  
  514. .endubloop    dbra    d7,.ubloop
  515.  
  516.         dbra    d3,.loop2
  517.  
  518. .endx        move.w    d5,d6        ; y
  519.         ble    .endxloop
  520.  
  521.         lsr.w    #3,d5
  522.         and.w    #7,d6
  523.  
  524.         mulu.w    #6,d6
  525.         neg.w    d6
  526.         jmp    (.endcopyloop2,pc,d6.w)
  527.  
  528. .copyloop2    REPT    8
  529.         move.b    (a5),(a3)    ; *bp = *otherbp
  530.         adda.l    d0,a5        ; otherbp += bytesperrow
  531.         adda.l    d0,a3        ; bp += bytesperrow
  532.         ENDR
  533. .endcopyloop2
  534.         dbra    d5,.copyloop2
  535.  
  536. .endxloop    dbra    d1,.xloop
  537.         movem.l    (sp)+,d2-d7/a2-a5
  538.         rts
  539.  
  540. ;***********************************************************************
  541.  
  542. ;void __asm unpackanim7long (register __a0 BYTE *bdata,
  543. ;                            register __a4 LONG *data,
  544. ;                            register __a1 PLANEPTR plane,
  545. ;                            register __d0 WORD bytesperrow,
  546. ;                            register __a2 WORD *dirty);
  547.  
  548. ; d1 = x
  549. ; d2 = temporary
  550. ; d3 = count
  551. ; d4 = w
  552. ; d5 = first
  553. ; d6 = last
  554. ; d7 = ub, temporary
  555.  
  556. ; a3 = lp
  557. ; a5 = y
  558.  
  559. _unpackanim7long
  560.         movem.l    d2-d7/a2-a5,-(sp)
  561.         ext.l    d0        ; bytesperrow
  562.         moveq    #0,d1        ; x = 0
  563. .xloop        moveq    #-1,d5        ; first = -1
  564.         moveq    #-1,d6        ; last = -1
  565.         movea.l    a1,a3        ; lp = plane
  566.         addq.l    #4,a1        ; plane++
  567.         suba.l    a5,a5        ; y = 0
  568.         moveq    #0,d3
  569.         move.b    (a0)+,d3    ; count = *bdata++
  570.         bra    .endloop2
  571. .loop2        moveq    #0,d4
  572.         move.b    (a0)+,d4    ; w = *bdata++
  573.         ble    1$        ; branch if w <= 0
  574.         adda.l    d4,a5        ; y += w
  575.         mulu.w    d0,d4
  576.         adda.l    d4,a3        ; lp += w * bytesperrow
  577.         dbra    d3,.loop2
  578.         bra    .endxloop
  579.  
  580. 1$        beq    3$        ; branch if w == 0
  581.         tst.w    d5
  582.         bge    2$        ; branch if first >= 0
  583.         move.w    a5,d5        ; first = y
  584. 2$        and.w    #$7f,d4        ; w &= 0x7f
  585.         adda.l    d4,a5        ; y += w
  586.         move.w    a5,d6        ; last = y
  587.         move.w    d4,d2
  588.         lsr.w    #3,d4
  589.         and.w    #7,d2
  590.         add.w    d2,d2
  591.         add.w    d2,d2
  592.         neg.w    d2
  593.         jmp    (.endwloop,pc,d2.w)
  594. .wloop        move.l    (a4)+,(a3)    ; *lp = *data++
  595.         adda.l    d0,a3        ; lp += bytesperrow
  596.         move.l    (a4)+,(a3)    ; *lp = *data++
  597.         adda.l    d0,a3        ; lp += bytesperrow
  598.         move.l    (a4)+,(a3)    ; *lp = *data++
  599.         adda.l    d0,a3        ; lp += bytesperrow
  600.         move.l    (a4)+,(a3)    ; *lp = *data++
  601.         adda.l    d0,a3        ; lp += bytesperrow
  602.         move.l    (a4)+,(a3)    ; *lp = *data++
  603.         adda.l    d0,a3        ; lp += bytesperrow
  604.         move.l    (a4)+,(a3)    ; *lp = *data++
  605.         adda.l    d0,a3        ; lp += bytesperrow
  606.         move.l    (a4)+,(a3)    ; *lp = *data++
  607.         adda.l    d0,a3        ; lp += bytesperrow
  608.         move.l    (a4)+,(a3)    ; *lp = *data++
  609.         adda.l    d0,a3        ; lp += bytesperrow
  610. .endwloop    dbra    d4,.wloop
  611.         dbra    d3,.loop2
  612.         bra    .endxloop
  613.  
  614. 3$        tst.w    d5
  615.         bge    4$        ; branch if first >= 0
  616.         move.w    a5,d5        ; first = y
  617. 4$        moveq    #0,d7
  618.         move.b    (a0)+,d7    ; ub = *bdata++
  619.         adda.l    d7,a5        ; y += ub
  620.         move.w    a5,d6        ; last = y
  621.         move.l    (a4)+,d4    ; w = *data++
  622.         move.w    d7,d2
  623.         lsr.w    #3,d7
  624.         and.w    #7,d2
  625.         add.w    d2,d2
  626.         add.w    d2,d2
  627.         neg.w    d2
  628.         jmp    (.endubloop,pc,d2.w)
  629. .ubloop        move.l    d4,(a3)        ; *lp = w
  630.         adda.l    d0,a3        ; lp += bytesperrow
  631.         move.l    d4,(a3)        ; *lp = w
  632.         adda.l    d0,a3        ; lp += bytesperrow
  633.         move.l    d4,(a3)        ; *lp = w
  634.         adda.l    d0,a3        ; lp += bytesperrow
  635.         move.l    d4,(a3)        ; *lp = w
  636.         adda.l    d0,a3        ; lp += bytesperrow
  637.         move.l    d4,(a3)        ; *lp = w
  638.         adda.l    d0,a3        ; lp += bytesperrow
  639.         move.l    d4,(a3)        ; *lp = w
  640.         adda.l    d0,a3        ; lp += bytesperrow
  641.         move.l    d4,(a3)        ; *lp = w
  642.         adda.l    d0,a3        ; lp += bytesperrow
  643.         move.l    d4,(a3)        ; *lp = w
  644.         adda.l    d0,a3        ; lp += bytesperrow
  645. .endubloop    dbra    d7,.ubloop
  646. .endloop2    dbra    d3,.loop2
  647.  
  648. .endxloop    tst.w    d5
  649.         blt    8$        ; branch if first < 0
  650.         move.w    (a2),d7
  651.         blt    5$        ; branch if dirty[0] < 0
  652.         cmp.w    d5,d7
  653.         ble    6$        ; branch if dirty[0] <= first
  654. 5$        move.w    d5,(a2)        ; dirty[0] = first
  655. 6$        move.w    (2,a2),d7
  656.         blt    7$        ; branch if dirty[1] < 0
  657.         cmp.w    d6,d7
  658.         bge    8$        ; branch if dirty[1] >= last
  659. 7$        move.w    d6,(2,a2)    ; dirty[1] = last
  660. 8$        addq.l    #4,a2        ; dirty += 2
  661.         addq.w    #4,d1        ; x += 4
  662.         cmp.w    d0,d1
  663.         blt    .xloop        ; branch if x < bytesperrow
  664.         movem.l    (sp)+,d2-d7/a2-a5
  665.         rts
  666.  
  667. ;***********************************************************************
  668.  
  669. ;void __asm unpackanim7longnodirty (register __a0 BYTE *bdata,
  670. ;                                   register __a4 LONG *data,
  671. ;                                   register __a1 PLANEPTR plane,
  672. ;                                   register __d0 WORD bytesperrow);
  673.  
  674. ; d1 = (bytesperrow - x) >> 2
  675. ; d3 = count
  676. ; d4 = w
  677. ; d6 = temporary
  678. ; d7 = ub, temporary
  679.  
  680. ; a3 = lp
  681.  
  682. _unpackanim7longnodirty
  683.         movem.l    d2-d7/a2-a4,-(sp)
  684.         ext.l    d0        ; bytesperrow
  685.         move.w    d0,d1
  686.         lsr.w    #2,d1
  687.         bra    .endxloop
  688. .xloop        movea.l    a1,a3        ; lp = plane
  689.         addq.l    #4,a1        ; plane++
  690.         moveq    #0,d3
  691.         move.b    (a0)+,d3    ; count = *bdata++
  692.         bra    .endloop2
  693.  
  694. .loop2        moveq    #0,d4
  695.         move.b    (a0)+,d4    ; w = *bdata++
  696.         ble    1$        ; branch if w <= 0
  697.         mulu.w    d0,d4
  698.         adda.l    d4,a3        ; lp += w * bytesperrow
  699.  
  700. .endloop2    dbra    d3,.loop2
  701.         bra    .endxloop
  702.  
  703. 1$        beq    3$        ; branch if w == 0
  704. 2$        and.w    #$7f,d4        ; w &= 0x7f
  705.         move.w    d4,d6
  706.         lsr.w    #3,d4
  707.         and.w    #7,d6
  708.         add.w    d6,d6
  709.         add.w    d6,d6
  710.         neg.w    d6
  711.         jmp    (.endwloop,pc,d6.w)
  712. .wloop        move.l    (a4)+,(a3)    ; *lp = *data++
  713.         adda.l    d0,a3        ; lp += bytesperrow
  714.         move.l    (a4)+,(a3)    ; *lp = *data++
  715.         adda.l    d0,a3        ; lp += bytesperrow
  716.         move.l    (a4)+,(a3)    ; *lp = *data++
  717.         adda.l    d0,a3        ; lp += bytesperrow
  718.         move.l    (a4)+,(a3)    ; *lp = *data++
  719.         adda.l    d0,a3        ; lp += bytesperrow
  720.         move.l    (a4)+,(a3)    ; *lp = *data++
  721.         adda.l    d0,a3        ; lp += bytesperrow
  722.         move.l    (a4)+,(a3)    ; *lp = *data++
  723.         adda.l    d0,a3        ; lp += bytesperrow
  724.         move.l    (a4)+,(a3)    ; *lp = *data++
  725.         adda.l    d0,a3        ; lp += bytesperrow
  726.         move.l    (a4)+,(a3)    ; *lp = *data++
  727.         adda.l    d0,a3        ; lp += bytesperrow
  728. .endwloop    dbra    d4,.wloop
  729.  
  730.         dbra    d3,.loop2
  731.         bra    .endxloop
  732.  
  733. 3$        moveq    #0,d7
  734.         move.b    (a0)+,d7    ; ub = *bdata++
  735.         move.l    (a4)+,d4    ; w = *data++
  736.         move.w    d7,d6
  737.         lsr.w    #3,d7
  738.         and.w    #7,d6
  739.         add.w    d6,d6
  740.         add.w    d6,d6
  741.         neg.w    d6
  742.         jmp    (.endubloop,pc,d6.w)
  743. .ubloop        move.l    d4,(a3)        ; *lp = w
  744.         adda.l    d0,a3        ; lp += bytesperrow
  745.         move.l    d4,(a3)        ; *lp = w
  746.         adda.l    d0,a3        ; lp += bytesperrow
  747.         move.l    d4,(a3)        ; *lp = w
  748.         adda.l    d0,a3        ; lp += bytesperrow
  749.         move.l    d4,(a3)        ; *lp = w
  750.         adda.l    d0,a3        ; lp += bytesperrow
  751.         move.l    d4,(a3)        ; *lp = w
  752.         adda.l    d0,a3        ; lp += bytesperrow
  753.         move.l    d4,(a3)        ; *lp = w
  754.         adda.l    d0,a3        ; lp += bytesperrow
  755.         move.l    d4,(a3)        ; *lp = w
  756.         adda.l    d0,a3        ; lp += bytesperrow
  757.         move.l    d4,(a3)        ; *lp = w
  758.         adda.l    d0,a3        ; lp += bytesperrow
  759. .endubloop    dbra    d7,.ubloop
  760.  
  761.         dbra    d3,.loop2
  762.  
  763. .endxloop    dbra    d1,.xloop
  764.         movem.l    (sp)+,d2-d7/a2-a4
  765.         rts
  766.  
  767. ;***********************************************************************
  768.  
  769. ;void __asm unpackanim7word (register __a0 BYTE *bdata,
  770. ;                            register __a4 WORD *data,
  771. ;                            register __a1 PLANEPTR plane,
  772. ;                            register __d0 WORD bytesperrow,
  773. ;                            register __a2 WORD *dirty);
  774.  
  775. ; d1 = x
  776. ; d2 = temporary
  777. ; d3 = count
  778. ; d4 = w
  779. ; d5 = first
  780. ; d6 = last
  781. ; d7 = ub, temporary
  782.  
  783. ; a3 = lp
  784. ; a5 = y
  785.  
  786. _unpackanim7word
  787.         movem.l    d2-d7/a2-a5,-(sp)
  788.         ext.l    d0        ; bytesperrow
  789.         moveq    #0,d1        ; x = 0
  790. .xloop        moveq    #-1,d5        ; first = -1
  791.         moveq    #-1,d6        ; last = -1
  792.         movea.l    a1,a3        ; lp = plane
  793.         addq.l    #2,a1        ; plane++
  794.         suba.l    a5,a5        ; y = 0
  795.         moveq    #0,d3
  796.         move.b    (a0)+,d3    ; count = *bdata++
  797.         bra    .endloop2
  798. .loop2        moveq    #0,d4
  799.         move.b    (a0)+,d4    ; w = *bdata++
  800.         ble    1$        ; branch if w <= 0
  801.         adda.l    d4,a5        ; y += w
  802.         mulu.w    d0,d4
  803.         adda.l    d4,a3        ; lp += w * bytesperrow
  804.         dbra    d3,.loop2
  805.         bra    .endxloop
  806.  
  807. 1$        beq    3$        ; branch if w == 0
  808.         tst.w    d5
  809.         bge    2$        ; branch if first >= 0
  810.         move.w    a5,d5        ; first = y
  811. 2$        and.w    #$7f,d4        ; w &= 0x7f
  812.         adda.l    d4,a5        ; y += w
  813.         move.w    a5,d6        ; last = y
  814.         move.w    d4,d2
  815.         lsr.w    #3,d4
  816.         and.w    #7,d2
  817.         add.w    d2,d2
  818.         add.w    d2,d2
  819.         neg.w    d2
  820.         jmp    (.endwloop,pc,d2.w)
  821. .wloop        move.w    (a4)+,(a3)    ; *lp = *data++
  822.         adda.l    d0,a3        ; lp += bytesperrow
  823.         move.w    (a4)+,(a3)    ; *lp = *data++
  824.         adda.l    d0,a3        ; lp += bytesperrow
  825.         move.w    (a4)+,(a3)    ; *lp = *data++
  826.         adda.l    d0,a3        ; lp += bytesperrow
  827.         move.w    (a4)+,(a3)    ; *lp = *data++
  828.         adda.l    d0,a3        ; lp += bytesperrow
  829.         move.w    (a4)+,(a3)    ; *lp = *data++
  830.         adda.l    d0,a3        ; lp += bytesperrow
  831.         move.w    (a4)+,(a3)    ; *lp = *data++
  832.         adda.l    d0,a3        ; lp += bytesperrow
  833.         move.w    (a4)+,(a3)    ; *lp = *data++
  834.         adda.l    d0,a3        ; lp += bytesperrow
  835.         move.w    (a4)+,(a3)    ; *lp = *data++
  836.         adda.l    d0,a3        ; lp += bytesperrow
  837. .endwloop    dbra    d4,.wloop
  838.         dbra    d3,.loop2
  839.         bra    .endxloop
  840.  
  841. 3$        tst.w    d5
  842.         bge    4$        ; branch if first >= 0
  843.         move.w    a5,d5        ; first = y
  844. 4$        moveq    #0,d7
  845.         move.b    (a0)+,d7    ; ub = *bdata++
  846.         adda.l    d7,a5        ; y += ub
  847.         move.w    a5,d6        ; last = y
  848.         move.w    (a4)+,d4    ; w = *data++
  849.         move.w    d7,d2
  850.         lsr.w    #3,d7
  851.         and.w    #7,d2
  852.         add.w    d2,d2
  853.         add.w    d2,d2
  854.         neg.w    d2
  855.         jmp    (.endubloop,pc,d2.w)
  856. .ubloop        move.w    d4,(a3)        ; *lp = w
  857.         adda.l    d0,a3        ; lp += bytesperrow
  858.         move.w    d4,(a3)        ; *lp = w
  859.         adda.l    d0,a3        ; lp += bytesperrow
  860.         move.w    d4,(a3)        ; *lp = w
  861.         adda.l    d0,a3        ; lp += bytesperrow
  862.         move.w    d4,(a3)        ; *lp = w
  863.         adda.l    d0,a3        ; lp += bytesperrow
  864.         move.w    d4,(a3)        ; *lp = w
  865.         adda.l    d0,a3        ; lp += bytesperrow
  866.         move.w    d4,(a3)        ; *lp = w
  867.         adda.l    d0,a3        ; lp += bytesperrow
  868.         move.w    d4,(a3)        ; *lp = w
  869.         adda.l    d0,a3        ; lp += bytesperrow
  870.         move.w    d4,(a3)        ; *lp = w
  871.         adda.l    d0,a3        ; lp += bytesperrow
  872. .endubloop    dbra    d7,.ubloop
  873. .endloop2    dbra    d3,.loop2
  874.  
  875. .endxloop    tst.w    d5
  876.         blt    8$        ; branch if first < 0
  877.         move.w    (a2),d7
  878.         blt    5$        ; branch if dirty[0] < 0
  879.         cmp.w    d5,d7
  880.         ble    6$        ; branch if dirty[0] <= first
  881. 5$        move.w    d5,(a2)        ; dirty[0] = first
  882. 6$        move.w    (2,a2),d7
  883.         blt    7$        ; branch if dirty[1] < 0
  884.         cmp.w    d6,d7
  885.         bge    8$        ; branch if dirty[1] >= last
  886. 7$        move.w    d6,(2,a2)    ; dirty[1] = last
  887. 8$        btst    #1,d1
  888.         beq    9$
  889.         addq.l    #4,a2        ; dirty += 2
  890. 9$        addq.w    #2,d1        ; x += 2
  891.         cmp.w    d0,d1
  892.         blt    .xloop        ; branch if x < bytesperrow
  893.         movem.l    (sp)+,d2-d7/a2-a5
  894.         rts
  895.  
  896. ;***********************************************************************
  897.  
  898. ;void __asm unpackanim7wordnodirty (register __a0 BYTE *bdata,
  899. ;                                   register __a4 WORD *data,
  900. ;                                   register __a1 PLANEPTR plane,
  901. ;                                   register __d0 WORD bytesperrow);
  902.  
  903. ; d1 = (bytesperrow - x) >> 2
  904. ; d3 = count
  905. ; d4 = w
  906. ; d6 = temporary
  907. ; d7 = ub, temporary
  908.  
  909. ; a3 = lp
  910.  
  911. _unpackanim7wordnodirty
  912.         movem.l    d2-d7/a2-a4,-(sp)
  913.         ext.l    d0        ; bytesperrow
  914.         move.w    d0,d1
  915.         lsr.w    #1,d1
  916.         bra    .endxloop
  917. .xloop        movea.l    a1,a3        ; lp = plane
  918.         addq.l    #2,a1        ; plane++
  919.         moveq    #0,d3
  920.         move.b    (a0)+,d3    ; count = *bdata++
  921.         bra    .endloop2
  922.  
  923. .loop2        moveq    #0,d4
  924.         move.b    (a0)+,d4    ; w = *bdata++
  925.         ble    1$        ; branch if w <= 0
  926.         mulu.w    d0,d4
  927.         adda.l    d4,a3        ; lp += w * bytesperrow
  928.  
  929. .endloop2    dbra    d3,.loop2
  930.         bra    .endxloop
  931.  
  932. 1$        beq    3$        ; branch if w == 0
  933. 2$        and.w    #$7f,d4        ; w &= 0x7f
  934.         move.w    d4,d6
  935.         lsr.w    #3,d4
  936.         and.w    #7,d6
  937.         add.w    d6,d6
  938.         add.w    d6,d6
  939.         neg.w    d6
  940.         jmp    (.endwloop,pc,d6.w)
  941. .wloop        move.w    (a4)+,(a3)    ; *lp = *data++
  942.         adda.l    d0,a3        ; lp += bytesperrow
  943.         move.w    (a4)+,(a3)    ; *lp = *data++
  944.         adda.l    d0,a3        ; lp += bytesperrow
  945.         move.w    (a4)+,(a3)    ; *lp = *data++
  946.         adda.l    d0,a3        ; lp += bytesperrow
  947.         move.w    (a4)+,(a3)    ; *lp = *data++
  948.         adda.l    d0,a3        ; lp += bytesperrow
  949.         move.w    (a4)+,(a3)    ; *lp = *data++
  950.         adda.l    d0,a3        ; lp += bytesperrow
  951.         move.w    (a4)+,(a3)    ; *lp = *data++
  952.         adda.l    d0,a3        ; lp += bytesperrow
  953.         move.w    (a4)+,(a3)    ; *lp = *data++
  954.         adda.l    d0,a3        ; lp += bytesperrow
  955.         move.w    (a4)+,(a3)    ; *lp = *data++
  956.         adda.l    d0,a3        ; lp += bytesperrow
  957. .endwloop    dbra    d4,.wloop
  958.  
  959.         dbra    d3,.loop2
  960.         bra    .endxloop
  961.  
  962. 3$        moveq    #0,d7
  963.         move.b    (a0)+,d7    ; ub = *bdata++
  964.         move.w    (a4)+,d4    ; w = *data++
  965.         move.w    d7,d6
  966.         lsr.w    #3,d7
  967.         and.w    #7,d6
  968.         add.w    d6,d6
  969.         add.w    d6,d6
  970.         neg.w    d6
  971.         jmp    (.endubloop,pc,d6.w)
  972. .ubloop        move.w    d4,(a3)        ; *lp = w
  973.         adda.l    d0,a3        ; lp += bytesperrow
  974.         move.w    d4,(a3)        ; *lp = w
  975.         adda.l    d0,a3        ; lp += bytesperrow
  976.         move.w    d4,(a3)        ; *lp = w
  977.         adda.l    d0,a3        ; lp += bytesperrow
  978.         move.w    d4,(a3)        ; *lp = w
  979.         adda.l    d0,a3        ; lp += bytesperrow
  980.         move.w    d4,(a3)        ; *lp = w
  981.         adda.l    d0,a3        ; lp += bytesperrow
  982.         move.w    d4,(a3)        ; *lp = w
  983.         adda.l    d0,a3        ; lp += bytesperrow
  984.         move.w    d4,(a3)        ; *lp = w
  985.         adda.l    d0,a3        ; lp += bytesperrow
  986.         move.w    d4,(a3)        ; *lp = w
  987.         adda.l    d0,a3        ; lp += bytesperrow
  988. .endubloop    dbra    d7,.ubloop
  989.  
  990.         dbra    d3,.loop2
  991.  
  992. .endxloop    dbra    d1,.xloop
  993.         movem.l    (sp)+,d2-d7/a2-a4
  994.         rts
  995.  
  996. ;***********************************************************************
  997.  
  998. ;void __asm unpackanim8long (register __a0 LONG *data,
  999. ;                            register __a1 PLANEPTR plane,
  1000. ;                            register __d0 WORD bytesperrow,
  1001. ;                            register __a2 WORD *dirty);
  1002.  
  1003. ; d1 = x
  1004. ; d2 = temporary
  1005. ; d3 = count
  1006. ; d4 = w
  1007. ; d5 = first
  1008. ; d6 = last
  1009. ; d7 = ub, temporary
  1010.  
  1011. ; a3 = lp
  1012. ; a4 = y
  1013.  
  1014. _unpackanim8long
  1015.         movem.l    d2-d7/a2-a4,-(sp)
  1016.         ext.l    d0        ; bytesperrow
  1017.         moveq    #0,d1        ; x = 0
  1018. .xloop        moveq    #-1,d5        ; first = -1
  1019.         moveq    #-1,d6        ; last = -1
  1020.         movea.l    a1,a3        ; lp = plane
  1021.         addq.l    #4,a1        ; plane++
  1022.         suba.l    a4,a4        ; y = 0
  1023.         move.l    (a0)+,d3    ; count = *data++
  1024.         bra    .endloop2
  1025. .loop2        move.l    (a0)+,d4    ; w = *data++
  1026.         ble    1$        ; branch if w <= 0
  1027.         adda.l    d4,a4        ; y += w
  1028.         mulu.w    d0,d4
  1029.         adda.l    d4,a3        ; lp += w * bytesperrow
  1030.         dbra    d3,.loop2
  1031.         bra    .endxloop
  1032.  
  1033. 1$        beq    3$        ; branch if w == 0
  1034.         tst.w    d5
  1035.         bge    2$        ; branch if first >= 0
  1036.         move.w    a4,d5        ; first = y
  1037. 2$        and.l    #$7fffffff,d4    ; w &= 0x7fffffff
  1038.         adda.l    d4,a4        ; y += w
  1039.         move.w    a4,d6        ; last = y
  1040.         move.w    d4,d2
  1041.         lsr.w    #3,d4
  1042.         and.w    #7,d2
  1043.         add.w    d2,d2
  1044.         add.w    d2,d2
  1045.         neg.w    d2
  1046.         jmp    (.endwloop,pc,d2.w)
  1047. .wloop        move.l    (a0)+,(a3)    ; *lp = *data++
  1048.         adda.l    d0,a3        ; lp += bytesperrow
  1049.         move.l    (a0)+,(a3)    ; *lp = *data++
  1050.         adda.l    d0,a3        ; lp += bytesperrow
  1051.         move.l    (a0)+,(a3)    ; *lp = *data++
  1052.         adda.l    d0,a3        ; lp += bytesperrow
  1053.         move.l    (a0)+,(a3)    ; *lp = *data++
  1054.         adda.l    d0,a3        ; lp += bytesperrow
  1055.         move.l    (a0)+,(a3)    ; *lp = *data++
  1056.         adda.l    d0,a3        ; lp += bytesperrow
  1057.         move.l    (a0)+,(a3)    ; *lp = *data++
  1058.         adda.l    d0,a3        ; lp += bytesperrow
  1059.         move.l    (a0)+,(a3)    ; *lp = *data++
  1060.         adda.l    d0,a3        ; lp += bytesperrow
  1061.         move.l    (a0)+,(a3)    ; *lp = *data++
  1062.         adda.l    d0,a3        ; lp += bytesperrow
  1063. .endwloop    dbra    d4,.wloop
  1064.         dbra    d3,.loop2
  1065.         bra    .endxloop
  1066.  
  1067. 3$        tst.w    d5
  1068.         bge    4$        ; branch if first >= 0
  1069.         move.w    a4,d5        ; first = y
  1070. 4$        move.l    (a0)+,d7    ; ub = *data++
  1071.         adda.l    d7,a4        ; y += ub
  1072.         move.w    a4,d6        ; last = y
  1073.         move.l    (a0)+,d4    ; w = *data++
  1074.         move.w    d7,d2
  1075.         lsr.w    #3,d7
  1076.         and.w    #7,d2
  1077.         add.w    d2,d2
  1078.         add.w    d2,d2
  1079.         neg.w    d2
  1080.         jmp    (.endubloop,pc,d2.w)
  1081. .ubloop        move.l    d4,(a3)        ; *lp = w
  1082.         adda.l    d0,a3        ; lp += bytesperrow
  1083.         move.l    d4,(a3)        ; *lp = w
  1084.         adda.l    d0,a3        ; lp += bytesperrow
  1085.         move.l    d4,(a3)        ; *lp = w
  1086.         adda.l    d0,a3        ; lp += bytesperrow
  1087.         move.l    d4,(a3)        ; *lp = w
  1088.         adda.l    d0,a3        ; lp += bytesperrow
  1089.         move.l    d4,(a3)        ; *lp = w
  1090.         adda.l    d0,a3        ; lp += bytesperrow
  1091.         move.l    d4,(a3)        ; *lp = w
  1092.         adda.l    d0,a3        ; lp += bytesperrow
  1093.         move.l    d4,(a3)        ; *lp = w
  1094.         adda.l    d0,a3        ; lp += bytesperrow
  1095.         move.l    d4,(a3)        ; *lp = w
  1096.         adda.l    d0,a3        ; lp += bytesperrow
  1097. .endubloop    dbra    d7,.ubloop
  1098. .endloop2    dbra    d3,.loop2
  1099.  
  1100. .endxloop    tst.w    d5
  1101.         blt    8$        ; branch if first < 0
  1102.         move.w    (a2),d7
  1103.         blt    5$        ; branch if dirty[0] < 0
  1104.         cmp.w    d5,d7
  1105.         ble    6$        ; branch if dirty[0] <= first
  1106. 5$        move.w    d5,(a2)        ; dirty[0] = first
  1107. 6$        move.w    (2,a2),d7
  1108.         blt    7$        ; branch if dirty[1] < 0
  1109.         cmp.w    d6,d7
  1110.         bge    8$        ; branch if dirty[1] >= last
  1111. 7$        move.w    d6,(2,a2)    ; dirty[1] = last
  1112. 8$        addq.l    #4,a2        ; dirty += 2
  1113.         addq.w    #4,d1        ; x += 4
  1114.         cmp.w    d0,d1
  1115.         blt    .xloop        ; branch if x < bytesperrow
  1116.         movem.l    (sp)+,d2-d7/a2-a4
  1117.         rts
  1118.  
  1119. ;***********************************************************************
  1120.  
  1121. ;void __asm unpackanim8longnodirty (register __a0 LONG *data,
  1122. ;                                   register __a1 PLANEPTR plane,
  1123. ;                                   register __d0 WORD bytesperrow);
  1124.  
  1125. ; d1 = (bytesperrow - x) >> 2
  1126. ; d3 = count
  1127. ; d4 = w
  1128. ; d7 = ub, temporary
  1129.  
  1130. ; a3 = lp
  1131.  
  1132. _unpackanim8longnodirty
  1133.         movem.l    d2-d7/a2-a3,-(sp)
  1134.         ext.l    d0        ; bytesperrow
  1135.         move.w    d0,d1
  1136.         lsr.w    #2,d1
  1137.         bra    .endxloop
  1138. .xloop        movea.l    a1,a3        ; lp = plane
  1139.         addq.l    #4,a1        ; plane++
  1140.         move.l    (a0)+,d3    ; count = *data++
  1141.         bra    .endloop2
  1142.  
  1143. .loop2        move.l    (a0)+,d4    ; w = *data++
  1144.         ble    1$        ; branch if w <= 0
  1145.         mulu.w    d0,d4
  1146.         adda.l    d4,a3        ; lp += w * bytesperrow
  1147.  
  1148. .endloop2    dbra    d3,.loop2
  1149.         bra    .endxloop
  1150.  
  1151. 1$        beq    3$        ; branch if w == 0
  1152. 2$        and.l    #$7fffffff,d4    ; w &= 0x7fffffff
  1153.         move.w    d4,d6
  1154.         lsr.w    #3,d4
  1155.         and.w    #7,d6
  1156.         add.w    d6,d6
  1157.         add.w    d6,d6
  1158.         neg.w    d6
  1159.         jmp    (.endwloop,pc,d6.w)
  1160. .wloop        move.l    (a0)+,(a3)    ; *lp = *data++
  1161.         adda.l    d0,a3        ; lp += bytesperrow
  1162.         move.l    (a0)+,(a3)    ; *lp = *data++
  1163.         adda.l    d0,a3        ; lp += bytesperrow
  1164.         move.l    (a0)+,(a3)    ; *lp = *data++
  1165.         adda.l    d0,a3        ; lp += bytesperrow
  1166.         move.l    (a0)+,(a3)    ; *lp = *data++
  1167.         adda.l    d0,a3        ; lp += bytesperrow
  1168.         move.l    (a0)+,(a3)    ; *lp = *data++
  1169.         adda.l    d0,a3        ; lp += bytesperrow
  1170.         move.l    (a0)+,(a3)    ; *lp = *data++
  1171.         adda.l    d0,a3        ; lp += bytesperrow
  1172.         move.l    (a0)+,(a3)    ; *lp = *data++
  1173.         adda.l    d0,a3        ; lp += bytesperrow
  1174.         move.l    (a0)+,(a3)    ; *lp = *data++
  1175.         adda.l    d0,a3        ; lp += bytesperrow
  1176. .endwloop    dbra    d4,.wloop
  1177.  
  1178.         dbra    d3,.loop2
  1179.         bra    .endxloop
  1180.  
  1181. 3$        move.l    (a0)+,d7    ; ub = *data++
  1182.         move.l    (a0)+,d4    ; w = *data++
  1183.         move.w    d7,d6
  1184.         lsr.w    #3,d7
  1185.         and.w    #7,d6
  1186.         add.w    d6,d6
  1187.         add.w    d6,d6
  1188.         neg.w    d6
  1189.         jmp    (.endubloop,pc,d6.w)
  1190. .ubloop        move.l    d4,(a3)        ; *lp = w
  1191.         adda.l    d0,a3        ; lp += bytesperrow
  1192.         move.l    d4,(a3)        ; *lp = w
  1193.         adda.l    d0,a3        ; lp += bytesperrow
  1194.         move.l    d4,(a3)        ; *lp = w
  1195.         adda.l    d0,a3        ; lp += bytesperrow
  1196.         move.l    d4,(a3)        ; *lp = w
  1197.         adda.l    d0,a3        ; lp += bytesperrow
  1198.         move.l    d4,(a3)        ; *lp = w
  1199.         adda.l    d0,a3        ; lp += bytesperrow
  1200.         move.l    d4,(a3)        ; *lp = w
  1201.         adda.l    d0,a3        ; lp += bytesperrow
  1202.         move.l    d4,(a3)        ; *lp = w
  1203.         adda.l    d0,a3        ; lp += bytesperrow
  1204.         move.l    d4,(a3)        ; *lp = w
  1205.         adda.l    d0,a3        ; lp += bytesperrow
  1206. .endubloop    dbra    d7,.ubloop
  1207.  
  1208.         dbra    d3,.loop2
  1209. .endxloop    dbra    d1,.xloop
  1210.         movem.l    (sp)+,d2-d7/a2-a3
  1211.         rts
  1212.  
  1213. ;***********************************************************************
  1214.  
  1215. ;void __asm unpackanim8word (register __a0 WORD *data,
  1216. ;                            register __a1 PLANEPTR plane,
  1217. ;                            register __d0 WORD bytesperrow,
  1218. ;                            register __a2 WORD *dirty);
  1219.  
  1220. ; d1 = x
  1221. ; d2 = temporary
  1222. ; d3 = count
  1223. ; d4 = w
  1224. ; d5 = first
  1225. ; d6 = last
  1226. ; d7 = ub, temporary
  1227.  
  1228. ; a3 = lp
  1229. ; a4 = y
  1230.  
  1231. _unpackanim8word
  1232.         movem.l    d2-d7/a2-a4,-(sp)
  1233.         ext.l    d0        ; bytesperrow
  1234.         moveq    #0,d1        ; x = 0
  1235. .xloop        moveq    #-1,d5        ; first = -1
  1236.         moveq    #-1,d6        ; last = -1
  1237.         movea.l    a1,a3        ; lp = plane
  1238.         addq.l    #2,a1        ; plane++
  1239.         suba.l    a4,a4        ; y = 0
  1240.         move.w    (a0)+,d3    ; count = *data++
  1241.         bra    .endloop2
  1242. .loop2        move.w    (a0)+,d4    ; w = *data++
  1243.         ble    1$        ; branch if w <= 0
  1244.         adda.w    d4,a4        ; y += w
  1245.         mulu.w    d0,d4
  1246.         adda.l    d4,a3        ; lp += w * bytesperrow
  1247.         dbra    d3,.loop2
  1248.         bra    .endxloop
  1249.  
  1250. 1$        beq    3$        ; branch if w == 0
  1251.         tst.w    d5
  1252.         bge    2$        ; branch if first >= 0
  1253.         move.w    a4,d5        ; first = y
  1254. 2$        and.w    #$7fff,d4    ; w &= 0x7fff
  1255.         adda.w    d4,a4        ; y += w
  1256.         move.w    a4,d6        ; last = y
  1257.         move.w    d4,d2
  1258.         lsr.w    #3,d4
  1259.         and.w    #7,d2
  1260.         add.w    d2,d2
  1261.         add.w    d2,d2
  1262.         neg.w    d2
  1263.         jmp    (.endwloop,pc,d2.w)
  1264. .wloop        move.w    (a0)+,(a3)    ; *lp = *data++
  1265.         adda.l    d0,a3        ; lp += bytesperrow
  1266.         move.w    (a0)+,(a3)    ; *lp = *data++
  1267.         adda.l    d0,a3        ; lp += bytesperrow
  1268.         move.w    (a0)+,(a3)    ; *lp = *data++
  1269.         adda.l    d0,a3        ; lp += bytesperrow
  1270.         move.w    (a0)+,(a3)    ; *lp = *data++
  1271.         adda.l    d0,a3        ; lp += bytesperrow
  1272.         move.w    (a0)+,(a3)    ; *lp = *data++
  1273.         adda.l    d0,a3        ; lp += bytesperrow
  1274.         move.w    (a0)+,(a3)    ; *lp = *data++
  1275.         adda.l    d0,a3        ; lp += bytesperrow
  1276.         move.w    (a0)+,(a3)    ; *lp = *data++
  1277.         adda.l    d0,a3        ; lp += bytesperrow
  1278.         move.w    (a0)+,(a3)    ; *lp = *data++
  1279.         adda.l    d0,a3        ; lp += bytesperrow
  1280. .endwloop    dbra    d4,.wloop
  1281.         dbra    d3,.loop2
  1282.         bra    .endxloop
  1283.  
  1284. 3$        tst.w    d5
  1285.         bge    4$        ; branch if first >= 0
  1286.         move.w    a4,d5        ; first = y
  1287. 4$        move.w    (a0)+,d7    ; ub = *data++
  1288.         adda.w    d7,a4        ; y += ub
  1289.         move.w    a4,d6        ; last = y
  1290.         move.w    (a0)+,d4    ; w = *data++
  1291.         move.w    d7,d2
  1292.         lsr.w    #3,d7
  1293.         and.w    #7,d2
  1294.         add.w    d2,d2
  1295.         add.w    d2,d2
  1296.         neg.w    d2
  1297.         jmp    (.endubloop,pc,d2.w)
  1298. .ubloop        move.w    d4,(a3)        ; *lp = w
  1299.         adda.l    d0,a3        ; lp += bytesperrow
  1300.         move.w    d4,(a3)        ; *lp = w
  1301.         adda.l    d0,a3        ; lp += bytesperrow
  1302.         move.w    d4,(a3)        ; *lp = w
  1303.         adda.l    d0,a3        ; lp += bytesperrow
  1304.         move.w    d4,(a3)        ; *lp = w
  1305.         adda.l    d0,a3        ; lp += bytesperrow
  1306.         move.w    d4,(a3)        ; *lp = w
  1307.         adda.l    d0,a3        ; lp += bytesperrow
  1308.         move.w    d4,(a3)        ; *lp = w
  1309.         adda.l    d0,a3        ; lp += bytesperrow
  1310.         move.w    d4,(a3)        ; *lp = w
  1311.         adda.l    d0,a3        ; lp += bytesperrow
  1312.         move.w    d4,(a3)        ; *lp = w
  1313.         adda.l    d0,a3        ; lp += bytesperrow
  1314. .endubloop    dbra    d7,.ubloop
  1315. .endloop2    dbra    d3,.loop2
  1316.  
  1317. .endxloop    tst.w    d5
  1318.         blt    8$        ; branch if first < 0
  1319.         move.w    (a2),d7
  1320.         blt    5$        ; branch if dirty[0] < 0
  1321.         cmp.w    d5,d7
  1322.         ble    6$        ; branch if dirty[0] <= first
  1323. 5$        move.w    d5,(a2)        ; dirty[0] = first
  1324. 6$        move.w    (2,a2),d7
  1325.         blt    7$        ; branch if dirty[1] < 0
  1326.         cmp.w    d6,d7
  1327.         bge    8$        ; branch if dirty[1] >= last
  1328. 7$        move.w    d6,(2,a2)    ; dirty[1] = last
  1329. 8$        btst    #1,d1
  1330.         beq    9$
  1331.         addq.l    #4,a2        ; dirty += 2
  1332. 9$        addq.w    #2,d1        ; x += 2
  1333.         cmp.w    d0,d1
  1334.         blt    .xloop        ; branch if x < bytesperrow
  1335.         movem.l    (sp)+,d2-d7/a2-a4
  1336.         rts
  1337.  
  1338. ;***********************************************************************
  1339.  
  1340. ;void __asm unpackanim8wordnodirty (register __a0 WORD *data,
  1341. ;                                   register __a1 PLANEPTR plane,
  1342. ;                                   register __d0 WORD bytesperrow);
  1343.  
  1344. ; d1 = (bytesperrow - x) >> 2
  1345. ; d3 = count
  1346. ; d4 = w
  1347. ; d7 = ub, temporary
  1348.  
  1349. ; a3 = lp
  1350.  
  1351. _unpackanim8wordnodirty
  1352.         movem.l    d2-d7/a2-a3,-(sp)
  1353.         ext.l    d0        ; bytesperrow
  1354.         move.w    d0,d1
  1355.         lsr.w    #1,d1
  1356.         bra    .endxloop
  1357. .xloop        movea.l    a1,a3        ; lp = plane
  1358.         addq.l    #2,a1        ; plane++
  1359.         move.w    (a0)+,d3    ; count = *data++
  1360.         bra    .endloop2
  1361.  
  1362. .loop2        move.w    (a0)+,d4    ; w = *data++
  1363.         ble    1$        ; branch if w <= 0
  1364.         mulu.w    d0,d4
  1365.         adda.l    d4,a3        ; lp += w * bytesperrow
  1366.  
  1367. .endloop2    dbra    d3,.loop2
  1368.         bra    .endxloop
  1369.  
  1370. 1$        beq    3$        ; branch if w == 0
  1371. 2$        and.w    #$7fff,d4    ; w &= 0x7fff
  1372.         move.w    d4,d6
  1373.         lsr.w    #3,d4
  1374.         and.w    #7,d6
  1375.         add.w    d6,d6
  1376.         add.w    d6,d6
  1377.         neg.w    d6
  1378.         jmp    (.endwloop,pc,d6.w)
  1379. .wloop        move.w    (a0)+,(a3)    ; *lp = *data++
  1380.         adda.l    d0,a3        ; lp += bytesperrow
  1381.         move.w    (a0)+,(a3)    ; *lp = *data++
  1382.         adda.l    d0,a3        ; lp += bytesperrow
  1383.         move.w    (a0)+,(a3)    ; *lp = *data++
  1384.         adda.l    d0,a3        ; lp += bytesperrow
  1385.         move.w    (a0)+,(a3)    ; *lp = *data++
  1386.         adda.l    d0,a3        ; lp += bytesperrow
  1387.         move.w    (a0)+,(a3)    ; *lp = *data++
  1388.         adda.l    d0,a3        ; lp += bytesperrow
  1389.         move.w    (a0)+,(a3)    ; *lp = *data++
  1390.         adda.l    d0,a3        ; lp += bytesperrow
  1391.         move.w    (a0)+,(a3)    ; *lp = *data++
  1392.         adda.l    d0,a3        ; lp += bytesperrow
  1393.         move.w    (a0)+,(a3)    ; *lp = *data++
  1394.         adda.l    d0,a3        ; lp += bytesperrow
  1395. .endwloop    dbra    d4,.wloop
  1396.  
  1397.         dbra    d3,.loop2
  1398.         bra    .endxloop
  1399.  
  1400. 3$        move.w    (a0)+,d7    ; ub = *data++
  1401.         move.w    (a0)+,d4    ; w = *data++
  1402.         move.w    d7,d6
  1403.         lsr.w    #3,d7
  1404.         and.w    #7,d6
  1405.         add.w    d6,d6
  1406.         add.w    d6,d6
  1407.         neg.w    d6
  1408.         jmp    (.endubloop,pc,d6.w)
  1409. .ubloop        move.w    d4,(a3)        ; *lp = w
  1410.         adda.l    d0,a3        ; lp += bytesperrow
  1411.         move.w    d4,(a3)        ; *lp = w
  1412.         adda.l    d0,a3        ; lp += bytesperrow
  1413.         move.w    d4,(a3)        ; *lp = w
  1414.         adda.l    d0,a3        ; lp += bytesperrow
  1415.         move.w    d4,(a3)        ; *lp = w
  1416.         adda.l    d0,a3        ; lp += bytesperrow
  1417.         move.w    d4,(a3)        ; *lp = w
  1418.         adda.l    d0,a3        ; lp += bytesperrow
  1419.         move.w    d4,(a3)        ; *lp = w
  1420.         adda.l    d0,a3        ; lp += bytesperrow
  1421.         move.w    d4,(a3)        ; *lp = w
  1422.         adda.l    d0,a3        ; lp += bytesperrow
  1423.         move.w    d4,(a3)        ; *lp = w
  1424.         adda.l    d0,a3        ; lp += bytesperrow
  1425. .endubloop    dbra    d7,.ubloop
  1426.  
  1427.         dbra    d3,.loop2
  1428.  
  1429. .endxloop    dbra    d1,.xloop
  1430.         movem.l    (sp)+,d2-d7/a2-a3
  1431.         rts
  1432.  
  1433. ;***********************************************************************
  1434.  
  1435.         end
  1436.